Introduction

• The three laws of TDD
• Continuous refactoring
• Basic continuous integration

• Spend more time discussing a few more of the S.O.L.I.D. principles,
• Refactoring to patterns
• Opening up classes using Ruby's Meta-Object Protocol

Note

• Example - in RSpec parlance, this refers to a series of steps describing a use of the system. Before writing production code, you'll write an example. That example will not run most of the time, so you'll then create the production code necessary to get the example to pass.
• Context - A context forms a common environment under-which Examples execute. A context may just be a name or it might include common setup and initialization as well as common clean-up. Contexts can be nested, which was demonstrated in the first tutorial.

Approach

• Title: Proceeded by a solid line, this will be at Heading Level 1
• Overview: The overview immediately follows the title
• Example: The Example be in a fixed-point font with different background.
• Check-in: As with the other tutorials, getting you to practice frequent checkings is a secondary goal so there will be not-so-subtle reminders along the way. If you find your tools don't support such a working style, that's valuable information as well.
• Refactor: There's almost always room for improvement, so the tutorial will review the work it just had you do and make suggestions as applicable. These refactorings are generally of the seconds-to-minutes variety. If an example requires a more significant restructuring, then it will be an entire sub-section in the Example.
• Check-in: After refactoring, checking in again.
• Summary: A synopsis of anything new or significant

The Problem

5 <enter>
3 
+
= 8

5 <enter> 3 + 6 * 3 / 4 ^
=65536

3 <enter> 6 <enter> -8 <enter> 89 + sqrt - +
=0

• 3, 6, -8 get places on the operand stack
• 8 is placed in "working storage" or in HP terminology, the x register
• +, a binary operator, takes as its left hand operand the top item on the stack, -8 and as its right hand operand the x register, 89. The result, 81, is placed in the x register
• Next, sqrt, a unary operator, takes the value on the x register and calculated 9, which is then put into the x register
• The first -, another binary operator, takes as its left-hand operator the top value on the stack, which is currently 6. It takes as its right-hand operator the x register, which is 9. The result, -3, is placed in the x register
• The first -, another binary operator, takes as its left-hand operator the top value on the stack, which is currently 6. It takes as its right-hand operator the x register, which is 9. The result, -3, is placed in the x register.
• The final operator, +, another binary operator, takes as its first operand the top item on the stack, which is 3. For its right-hand operand, it takes the x register, -3. Adding, the result is 0, which becomes the value in the x register.
• The stack is empty.

The x register

• If the next key is part of a number, the x register is reset and the key pressed becomes the contents of the x register.
• If the next key is not part of a number, then it applies as is.

Getting Started

• Handling input
• Handling the stack and the x register properly
• Processing the basic operators (+, -, /, *, ^)
• Handling more complex functions (e.g., prime factors, sum over the stack)

• CRUD'ing (Create, Read, Update, Delete) variables
• CRUD'ing user-defined functions

Your Work Area

• Create a directory to store all of your work. Unlike the first tutorial, you'll be working in multiple files this time.

The 0th Example

describe "Basic Creation" do
  it "should be non-null after creation" do
    calculator = RpnCalculator.new
  end
end

• Create this Example in your directory, call the file "rpn_calculator_spec.rb"

• Execute the Example, it fails:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  Basic Creation
  - should be non-null after creation (ERROR - 1)
   
  1)
  NameError in 'Basic Creation should be non-null after creation'
  uninitialized constant RpnCalculator
  ./rpn_calculator_spec.rb:3:
   
  Finished in 0.013091 seconds
   
  1 example, 1 failure

• Create the following Ruby class in a file called rpn_calculator.rb:
  

  class RpnCalculator
  end

• Update rpn_calculator_spec.rb to require the file you just created:
  

  require 'rpn_calculator'
   
  describe "Basic Creation" do
    ...
  end

• Run your Example again, you should be all green:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  Basic Creation
  - should be non-null after creation
   
  Finished in 0.0123 seconds
   
  1 example, 0 failures

• Update the Example to validate calculator:
  

      calculator.should_not be nil

• Run your Example again, you should be all green:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  Basic Creation
  - should be non-null after creation
   
  Finished in 0.0123 seconds
   
  1 example, 0 failures

Macintosh-7% ls
rpn_calculator.rb  rpn_calculator_spec.rb  wikiwriteup.txt
Macintosh-7% git init
Initialized empty Git repository in /Users/schuchert/src/ruby/bdd_tutorial_2/.git/
Macintosh-7% git add *   
Macintosh-7% git commit
Created initial commit 05273da: First spec passing.
 3 files changed, 354 insertions(+), 0 deletions(-)
 create mode 100644 rpn_calculator.rb
 create mode 100644 rpn_calculator_spec.rb
 create mode 100644 wikiwriteup.txt

require 'rpn_calculator'
 
describe "Basic Creation" do
  it "should be non-null after creation" do
    calculator = RpnCalculator.new
    calculator.should_not be nil
  end
end

class RpnCalculator
end

• You have a working environment
• The RSpec gem is installed
• Ruby is intalled
• You have the basic files in place
• You've checked your work into a repository

• If you get distracted, you don't lose very much ground.
• If you mess up and need a do-over, you don't lose too much work.
• If someone needs your attention, you're not too far from having a great place to stop what you're doing.
• You can feel a sense of accomplishment throughout the day.
• You can watch as your system organically grows from something trivial, to something complex, typically quickly.

Example: Accepting User Input

1. The system receives a series of events for buttons pressed, e.g., pressing "9" on the UI generates a 9-button pressed event, pressing "sqrt" on the UI generates a sqrt-button pressed event.
2. The system receives "digit" messages for digits or "function" messages for functions.
3. The system receives messages such as a complete number, enter, + and so on.

describe "Handling User Input of Numbers" do
  it "should store a series of digits in the x register" do
    calculator = RpnCalculator.new
    calculator.digit_pressed '4'
  end
end

• Create this Example, adding it to rpn_calculator_spec.rb.

• Execute the Example, you should see an error similar to the following:
  

  1)
  NoMethodError in 'Handling User Input of Numbers should store a series of digits in the x register'
  undefined method `digit_pressed' for #<RpnCalculator:0x58kkc80c>
  ./rpn_calculator_spec.rb:12:
   
  Finished in 0.015707 seconds
   
  2 examples, 1 failure

• Update RpnCalculator:
  

  class RpnCalculator
    def digit_pressed(digit)
    end
  end

• Verify that your Example now executes successfully.

• Complete the Example:
  

  describe "Handling User Input of Numbers" do
    it "should store a series of digits in the x register" do
      calculator = RpnCalculator.new
      calculator.digit_pressed '4'
      calculator.digit_pressed '2'
      calculator.x_register.should == 42
    end
  end

• Execute your examples, one will fail:
  

  1)
  NoMethodError in 'Handling User Input of Numbers should store a series of digits in the x register'
  undefined method `x_register' for #<RpnCalculator:0x58c5dc>
  ./rpn_calculator_spec.rb:14:
   
  Finished in 0.015999 seconds
   
  2 examples, 1 failure

• First, create the method in RpnCalculator to get your code to compiling:
  

    def x_register
    end

• Run your Example, make sure it is failing:
  

  1)
  'Handling User Input of Numbers should store a series of digits in the x register' FAILED
  expected: 42,
       got: nil (using ==)
  ./rpn_calculator_spec.rb:14:
   
  Finished in 0.016444 seconds
   
  2 examples, 1 failure

• Now, do the simplest thing that could work, AKA fast-green bar, AKA, Uncle Bob's TDD rules, #3:
  

    def x_register
      42
    end

• Finally, run your Examples to make sure they are passing:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  Basic Creation
  - should be non-null after creation
   
  Handling User Input of Numbers
  - should store a series of digits in the x register
   
  Finished in 0.014956 seconds
   
  2 examples, 0 failures

• Check in your work:
  

  Macintosh-7% git commit -a
  Created commit 727745f: Added basic support for handling digits.
   3 files changed, 215 insertions(+), 2 deletions(-)

• Create a containing context:
  Above the first describe
  

  describe "RPN Calculator" do

  
  After the last end
  

  end

  
  Update the spacing - that's one command in VI, the best-ever editor
  

  describe "RPN Calculator"
    describe "Basic Creation" do
      ...
    end
   
    describe "Handling User Input of Numbers" do
      ...
    end
  end

• Verify that your Examples still execute:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  RPN Calculator
   
  RPN Calculator Basic Creation
  - should be non-null after creation
   
  RPN Calculator Handling User Input of Numbers
  - should store a series of digits in the x register
   
  Finished in 0.016923 seconds
   
  2 examples, 0 failures

• Add a common setup to your outer-context:
  

    before(:each) do
      @calculator = RpnCalculator.new
    end

• Verify your Examples still run.

• Update the first Example to use the initialized calculator:
  

    describe "Basic Creation" do
      it "should be non-null after creation" do
        @calculator.should_not be nil
      end
    end

• Verify your Examples still run.

• Update the second Example as well:
  

    describe "Handling User Input of Numbers" do
      it "should store a series of digits in the x register" do
        @calculator.digit_pressed '4'
        @calculator.digit_pressed '2'
        @calculator.x_register.should == 42
      end
    end

• Verify your Examples still run.

• Check in your work:
  

  Macintosh-7% git commit -a
  Created commit b203185: Removed duplication of calculator initialization.
   2 files changed, 128 insertions(+), 18 deletions(-)
   rewrite rpn_calculator_spec.rb (90%)

• You want to get to the point where your muscle memory is imbued with this kind of basic cleanup. The only way to get there is practice.
• We removed a violation of the DRY principle. I believe Ruby Dave Thomas is credited with saying all design is an exercise in removing duplication. Regardless of who said it, I think it's a sound idea.

Example: Taking a decimal point as well

•   describe "Handling an even longer User Input of Numbers" do
      it "should store a series of digits in the x register" do
        @calculator.digit_pressed '1'
        @calculator.digit_pressed '2'
        @calculator.digit_pressed '4'
        @calculator.digit_pressed '3' 
        @calculator.digit_pressed '2' 
        @calculator.x_register.should == 12432
      end

• More examples --> longer to run --> run less often --> less effective
• When something breaks, you are likely to break more than one Example --> more maintenance --> Examples become a hassle to maintain --> Examples are commented out or left not passing --> nearly defeats the purpose of BDD.

    it "should handle a string of digits with an embedded ." do
      @calculator.digit_pressed '1' 
      @calculator.digit_pressed '3' 
      @calculator.digit_pressed '.'
      @calculator.digit_pressed '3'
      @calculator.digit_pressed '1'
      @calculator.x_register.should == 13.31
    end

• Create this Example.

• Run your Examples, you should have one failure:
  

  ... <snip> ...
  - should handle a string of digits with an embedded . (FAILED - 1)
   
  1)
  'RPN Calculator Handling User Input of Numbers should handle a string of digits with an embedded .' FAILED
  expected: 13.31,
       got: 42 (using ==)
  ./rpn_calculator_spec.rb:27:
   
  Finished in 0.018738 seconds
   
  3 examples, 1 failure

• Add an initialization method to your RpnCalculator class:
  

    def initialize
      @input = ''
    end

• Update the digit_pressed method to record the digit:
  

    def digit_pressed(digit)
      @input << digit.to_s
    end

• Update the x_register method to use the recorded input:
  

    def x_register
      @input.to_f
    end

• Run your Examples, you should be all green:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  RPN Calculator
   
  RPN Calculator Basic Creation
  - should be non-null after creation
   
  RPN Calculator Handling User Input of Numbers
  - should store a series of digits in the x register
  - should handle a string of digits with an embedded .
   
  Finished in 0.018312 seconds
   
  3 examples, 0 failures

• It is once again time to check in your code. Everything is green:
  

  Macintosh-7% git commit -a
  Created commit e10de87: Added support for numbers with decimals.
   3 files changed, 135 insertions(+), 2 deletions(-)

• Add a method to the containing context:
  

  describe "RPN Calculator" do
    ...
    def enter_number(number)
      number.to_s.each_char{ |d| @calculator.digit_pressed d }
    end
    ...
  end

• Run your Examples, they should still pass.

• Update the "Handling User Input of Numbers" example:
  

      it "should store a series of digits in the x register" do
        enter_number 42
        @calculator.x_register.should == 42
      end

• Run your Examples, they should still pass.

• Update the "should handle a string of digits with an embedded ." Example:
  

      it "should handle a string of digits with an embedded ." do
        enter_number 13.31
        @calculator.x_register.should == 13.31
      end

• Run your Examples, they should still pass.

• Finally, the second Example does not start with should, which is a pretty well-followed practice. So fix it:
  

    describe "Handling integers" do
      it "should store a series of digits in the x register" do
        enter_number 42
        @calculator.x_register.should == 42
      end

• Run your Examples, they should still pass.
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  RPN Calculator
   
  RPN Calculator Basic Creation
  - should be non-null after creation
   
  RPN Calculator Handling integers
  - should store a series of digits in the x register
  - should handle a string of digits with an embedded .
   
  Finished in 0.017654 seconds
   
  3 examples, 0 failures

• Check in your changes:
  

  Macintosh-7% git commit -a
  Created commit a465d16: Removed duplication in writing examples taking numbes.
   2 files changed, 56 insertions(+), 24 deletions(-)

require 'rpn_calculator'
 
describe "RPN Calculator" do
  before(:each) do
    @calculator = RpnCalculator.new
  end
 
  def enter_number(number)
    number.to_s.each_char{ |d| @calculator.digit_pressed d }
  end
 
  describe "Basic Creation" do
    it "should be non-null after creation" do
      @calculator.should_not be nil
    end
  end
 
  describe "Handling integers" do
    it "should store a series of digits in the x register" do
      enter_number 42
      @calculator.x_register.should == 42
    end
 
    it "should handle a string of digits with an embedded ." do
      enter_number 13.31
      @calculator.x_register.should == 13.31
    end
  end
end

class RpnCalculator
  def initialize
    @input = ''
  end
 
  def digit_pressed(digit)
    @input << digit.to_s
  end 
 
  def x_register
    @input.to_f
  end
end 

Example: What Happens with Enter?

• The current value in the x_register is placed on the stack of previous operands.
• Subsequent, the next numeric digit causes the x_register to reset, but pressing <enter> again causes that value to placed on the stack again.

  describe "Handling the <enter> key" do
    it "should copy x_register to top of stack" 
 
    it "should cause next digit to reset the x_register" 
 
    it "should allow the x_register to be <entered> again" 
  end

• Add this context as a sub-context of the RPN Calculator context.

• Execute your Examples, you should notice that these three are listed as pending:
  

  RPN Calculator Handling the <enter> key
  - should copy x_register to top of stack (PENDING: Not Yet Implemented)
  - should cause next digit to reset the x_register (PENDING: Not Yet Implemented)
  - should allow the x_register to be <entered> again (PENDING: Not Yet Implemented)
   
  Pending:
  RPN Calculator Handling the <enter> key should copy x_register to top of stack (Not Yet Implemented)
  RPN Calculator Handling the <enter> key should cause next digit to reset the x_register (Not Yet Implemented)
  RPN Calculator Handling the <enter> key should allow the x_register to be <entered> again (Not Yet Implemented)
   
  Finished in 0.022477 seconds
   
  6 examples, 0 failures, 3 pending

1. Add a method, enter_pressed.
2. Add a method, execute_function(:enter)

• The first option suggests a "wide" API. That is, the number of methods on the PN Calculator grows as its functionality grows. This might sound "normal" but it could be a violation of the Open/Closed Principle.
• The second option requires a symbol for each function.
• The second option requires the RPN calculator to map from a symbol, :enter, to a behavior.

• Add to the first Example (make sure to add the 'do' after the first line):
  

      it "should copy x_register to top of stack" do
        enter_number 654
        @calculator.execute_function(:enter)
      end

• Run your Examples to verify this:
  

  1)
  NoMethodError in 'RPN Calculator Handling the <enter> key should copy x_register to top of stack'
  undefined method `execute_function' for #<RpnCalculator:0x587ac8 @input="654">
  ./rpn_calculator_spec.rb:33:
   
  Finished in 0.023074 seconds
   
  6 examples, 1 failure, 2 pending

• Get the example back to Green by adding a method in RpnCalculator:
  

    def execute_function(function_symbol)
    end

• Continue with the Example:
  

      it "should copy x_register to top of stack" do
        enter_number 654
        @calculator.execute_function(:enter)
        @calculator.top.should == 654
      end

• Add a top method:
  

    def top
      654
    end

• Created a method that would cause the Example to fail.
• Run your Examples.
• Updated the method to return 654
• Run your Examples.

• Sure:
  

  Macintosh-7% !g
  git commit -a
  Created commit f77e000: Added support for the "enter" function.
   3 files changed, 148 insertions(+), 7 deletions(-)

Example: Checking that the x_register is reset-able

    it "should cause next digit to reset the x_register" do
      enter_number 654
      @calculator.execute_function(:enter)
      enter_number 1
      @calculator.x_register.should == 1
    end

• Create this Example and then run you Examples:
  

  1)
  'RPN Calculator Handling the <enter> key should cause next digit to reset the x_register' FAILED
  expected: 1,
       got: 6541.0 (using ==)
  ./rpn_calculator_spec.rb:41:
   
  Finished in 0.023285 seconds
   
  6 examples, 1 failure, 1 pending

• Update the calculator to work with the new Example:
  

    def digit_pressed(digit)
      @input = '' if @x_register_should_reset
      x_register_should_reset = false
      @input << digit.to_s
    end
   
    def execute_function(function_symbol)
      @x_register_should_reset = true
    end

• Run your Examples, they should pass:
  

  RPN Calculator Handling the <enter> key
  - should copy x_register to top of stack
  - should cause next digit to reset the x_register
  - should allow the x_register to be <entered> again (PENDING: Not Yet Implemented)
   
  Pending:
  RPN Calculator Handling the <enter> key should allow the x_register to be <entered> again (Not Yet Implemented)
   
  Finished in 0.022283 seconds
   
  6 examples, 0 failures, 1 pending

• Now is a good time to check in, even though you have a pending Example:
  

  Macintosh-7% !g
  git commit -a
  Created commit d8902e3: Added resetting of x_register after :enter
   3 files changed, 65 insertions(+), 3 deletions(-)

• There's a violation of DRY between digit_pressed and initialize
• There's some duplication between the last two Examples
• The method name enter_number either needs to be changed, or it should call the <enter> method.

•   def enter_number(number)
      number.to_s.each_char{ |d| @calculator.digit_pressed d }
      @calculator.execute_function(:enter)
    end

• Run your Examples, nothing is broken.

  def digit_pressed(digit)
    initialize if @x_register_should_reset
    x_register_should_reset = false
    @input << digit.to_s
  end

• Add a new method:
  

    def reset_input
      @input = ''
    end

• Verify that nothing broke.

• Update initialize and digit_pressed to use this new method.

• Verify that nothing broke.

    it "should copy x_register to top of stack" do
      enter_number 654
      @calculator.top.should == 654
    end
 
    it "should cause next digit to reset the x_register" do
      enter_number 654
      @calculator.digit_pressed 1
      @calculator.x_register.should == 1
    end

• Check in your work.
  

  Macintosh-7% !g
  git commit -a
  Created commit a8fec92: Refactored input resetting, enter_number now 
   3 files changed, 75 insertions(+), 8 deletions(-)

• Perfection is not a destination, it is a journey.

Example: Should allow x_register to be entered again

• There's going to be a stack of numbers somewhere.
• Once the calculator starts resetting, the code never stops, so the Examples have left work on the plate.

• Create the following example:
  

      it "should allow the x_register to be <entered> again" do
        enter_number 654
        @calculator.execute_function(:enter)
        @calculator.top.should == 654
        @calculator.x_register.should == 654
      end

• Run your Examples:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  RPN Calculator
   
  RPN Calculator Basic Creation
  - should be non-null after creation
   
  RPN Calculator Handling integers
  - should store a series of digits in the x register
  - should handle a string of digits with an embedded .
   
  RPN Calculator Handling the <enter> key
  - should copy x_register to top of stack
  - should cause next digit to reset the x_register
  - should allow the x_register to be <entered> again
   
  Finished in 0.022528 seconds
   
  6 examples, 0 failures

• Commit:
  

  Macintosh-7% !g
  git commit -a
  Created commit 437ee9f: Added candidate Example. Might remove it shortly,.
   2 files changed, 51 insertions(+), 8 deletions(-)

Example: Resetting after the first digit

• Create the following example.
  

      it "should only reset after the first digit and not subsequent digits" do
        enter_number 654
        enter_number 27
        @calculator.x_register.should == 27
      end

• Run your Examples, notice the failure:
  

  - should only reset after the first digit and not subsequent digits (FAILED - 1)
   
  1)
  'RPN Calculator Handling the <enter> key should only reset after the first digit and not subsequent digits' FAILED
  expected: 27,
       got: 7.0 (using ==)
  ./rpn_calculator_spec.rb:53:
   
  Finished in 0.023869 seconds
   
  7 examples, 1 failure

  def digit_pressed(digit)
    if @x_register_should_reset
      reset_input 
      @x_register_should_reset = false
    end
    @input << digit.to_s
  end

  def reset_input
    @input = ''
    @x_register_should_reset = false
  end

• Fix this by updating the reset_input method.

• Make sure your Examples pass:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb
   
  RPN Calculator
   
  RPN Calculator Basic Creation
  - should be non-null after creation
   
  RPN Calculator Handling integers
  - should store a series of digits in the x register
  - should handle a string of digits with an embedded .
   
  RPN Calculator Handling the <enter> key
  - should copy x_register to top of stack
  - should cause next digit to reset the x_register
  - should allow the x_register to be <entered> again
  - should only reset after the first digit and not subsequent digits
   
  Finished in 0.025639 seconds
   
  7 examples, 0 failures

• Check in your work, you've made some good progress:
  

  Macintosh-7% !g
  git commit -a
  Created commit e1a018b: Added Example to verify that resetting was turned off.
   3 files changed, 139 insertions(+), 5 deletions(-)

    before(:each) do
      enter_number 654
    end

• Add the before method and run your Examples. Make sure all Examples still pass.

• Now, remove the first enter_number 654 from each of the subsequent Examples.

• Verify that all of your Examples still pass.

Example: Enter actually puts values on the stack

7 <enter>
14 <enter>
99

• The x_register has a value of 99.
• The x_register can still receive receive digits.
• The first previous value is 14.
• The second previous value is 7.

    it "should have two operands available after one <enter>" do
      @calculator.available_operands.should == 2
    end

• Create this example.

• Add the missing method with an empty implementation.

• Get the example to pass:
  

    def available_operands
      2
    end

• Verify that all of your Examples now pass.

• Check in your work.

Example: Enter should increase the number of operands

    it "should increase the operand count after each <enter>" do
      enter_number 13
      @calculator.available_operands.should == 3
    end

• Create this Example. Notice that since you added no new API calls to the RpnCalculator's interface, you can write the complete Example while following the second law of TDD/BDD.

• Verify that your Example fails:
  

  - should increase the operand count after each <enter> (FAILED - 1)
   
  1)
  'RPN Calculator Handling the <enter> key should increase the operand count after each <enter>' FAILED
  expected: 3,
       got: 2 (using ==)
  ./rpn_calculator_spec.rb:62:
   
  Finished in 0.026028 seconds
   
  9 examples, 1 failure

  def initialize
    reset_input
    @op_count = 1
  end

  def execute_function(function_symbol)
    @x_register_should_reset = true
    @op_count += 1
  end 

  def available_operands
    @op_count
  end

  def initialize
    reset_input
    @operands = []
  end

  def execute_function(function_symbol)
    @x_register_should_reset = true
    @operands << x_register
  end

  def available_operands
    @operands.length + 1
  end

• Writing only enough code means you are less likely to over-design or gold-plate your solution.
• It also helps keep the production code actually covered by tests.

• Implement the second solution.

• Verify that all of your Examples pass.

• Check in your work.

• Experiment, change the implementation of top:
  

    def top
      @operands.last
    end 

• Run your Examples, everything still passes.

• Check in simple refactoring.

Example: The right thing is on the stack

  describe "Stack" do
    it "should contain the correct items in the correct order" do
      enter_number 4
      enter_number 19
      enter_number -1
      @calculator.pop!.should == -1
      @calculator.pop!.should == 19
      @calculator.pop!.should == 4
    end
  end 

• Create the Example, verify that the test fails as expected.

• Add an empty pop! method to verify that the Example fails for the right reason:
  

    def pop!
    end

• Run your Examples.

• Implement pop!:
  

    def pop!
      @operands.pop
    end

• Verify that your Examples pass.

• Check in your work.

Example: What happens with an 'Empty' stack?

    it "should return 0 when pop!'ing from an empty stack" do
      @calculator.pop!.should == 0
    end
 
    it "should return 0 for top when stack empty" do
      @calculator.top.should == 0
    end

• Create these Examples, they will both fail the same way:
  

  - should return 0 when pop!'ing from an empty stack (FAILED - 1)
  - should return 0 for top when stack empty (FAILED - 2)
   
  1)
  'RPN Calculator Stack should return 0 when pop!'ing from an empty stack' FAILED
  expected: 0,
       got: nil (using ==)
  ./rpn_calculator_spec.rb:77:
   
  2)
  'RPN Calculator Stack should return 0 for top when stack empty' FAILED
  expected: 0,
       got: nil (using ==)
  ./rpn_calculator_spec.rb:81:
   
  Finished in 0.031744 seconds
   
  12 examples, 2 failures

• When code pop's values off of an empty array, the array returns nil. The same thing happens when code calls top. This will fix both of your failing Examples:
  

    def top
      @operands.length > 0 ? @operands.last : 0
    end
   
    def pop!
      @operands.length > 0 ? @operands.pop : 0
    end

• Make these changes and verify all of your Examples are passing.

  def create_operand_stack
    stack = []
    def stack.pop!
      return length > 0 ? super : 0
    end
 
    def stack.top
      return length > 0 ? last : 0
    end
    stack
  end
 
  custom_stack = create_operand_stack
 
  puts custom_stack.top == 0
  puts custom_stack.pop! == 0

• There are 3 Examples in the "Stack" context. Move the first one out into "Handling the <enter> key" context.

• Verify that all of your Examples are still passing.

• Change the structure of rpn_calculator_spec.rb:
  

  describe "RPN Calculator" do
    ...
  end
   
  describe "Stack" do
    ...
  end

• Update the "Stack" context:
  

  describe "OperandStack" do
    before (:each) do
      @stack = OperandStack.new
    end
   
    it "should return 0 when pop!'ing from an empty stack" do
      @stack.pop!.should == 0
    end
   
    it "should return 0 for top when stack empty" do
      @stack.top.should == 0
    end
  end

• Move the entire OperandStack context into a new file called "operand_stack_spec.rb".

• Now your rpn_calculator_spec will pass:
  

  Macintosh-7% spec -f s -c rpn_calculator_spec.rb     
   
  RPN Calculator
   
  RPN Calculator Basic Creation
  - should be non-null after creation
   
  RPN Calculator Handling integers
  - should store a series of digits in the x register
  - should handle a string of digits with an embedded .
   
  RPN Calculator Handling the <enter> key
  - should copy x_register to top of stack
  - should cause next digit to reset the x_register
  - should allow the x_register to be <entered> again
  - should only reset after the first digit and not subsequent digits
  - should have two operands available after one <enter>
  - should increase the operand count after each <enter>
  - should contain the correct items in the correct order
   
  Finished in 0.027715 seconds
   
  10 examples, 0 failures

• Next, create a new class called OperandStack in a file called opeand_stack.rb:
  

  class OperandStack
    def initialize
      @operands = []
    end
   
    def top
      @operands.length > 0 ? @operands.last : 0
    end
   
    def available_operands
      @operands.length + 1
    end
   
    def pop!
      @operands.length > 0 ? @operands.pop : 0
    end
   
    def <<(value)
      @operands << value
    end
  end

• Verify that your operand_stack_spec.rb now passes:
  

  Macintosh-7% spec -f s -c operand_stack_spec.rb
   
  OperandStack
  - should return 0 when pop!'ing from an empty stack
  - should return 0 for top when stack empty
   
  Finished in 0.013598 seconds
   
  2 examples, 0 failures

• Run all of your Examples, everything should be passing:
  

  Macintosh-7% spec -f s -c *_spec.rb
   
  OperandStack
  - should return 0 when pop!'ing from an empty stack
  - should return 0 for top when stack empty
   
  RPN Calculator
   
  RPN Calculator Basic Creation
  - should be non-null after creation
   
  RPN Calculator Handling integers
  - should store a series of digits in the x register
  - should handle a string of digits with an embedded .
   
  RPN Calculator Handling the <enter> key
  - should copy x_register to top of stack
  - should cause next digit to reset the x_register
  - should allow the x_register to be <entered> again
  - should only reset after the first digit and not subsequent digits
  - should have two operands available after one <enter>
  - should increase the operand count after each <enter>
  - should contain the correct items in the correct order
   
  Finished in 0.029495 seconds
   
  12 examples, 0 failures

• All of your Examples are passing, right? Now is a great time to check in before moving to the next step.

• Add "require 'operand_stack' to the beginning of your rpn_calculator.rb file.

• Update the initialize method:
  

    def initialize
      reset_input 
      @operands = []
      @operand_stack = OperandStack.new
    end

• Run your Examples, everything should still pass.

• Update execute_function to duplicate the work of storing the x_register:
  

    def execute_function(function_symbol)
      @x_register_should_reset = true
      @operands << x_register
      @operand_stack << x_register
    end

• Run your Examples, everything should still pass.

• Update top:
  

    def top
      @operand_stack.top
    end

• Run your Examples, everything should still pass.

• Update pop!:
  

    def pop!
      @operand_stack.pop!
    end

• Reviewing available_operands, you notice that there's no length method on Operand stack. So add it:
  

    def length
      @operands.length
    end

• Run your Examples, everything should still pass.

• Update available_operands:
  

    def available_operands
      @operand_stack.length + 1
    end

• At this point, you can remove all code that refers to @operands (you'll change 2 places).

• Run your Examples, everything should still pass.

• It's like riding a horse on the interstate.

require 'rpn_calculator'
 
describe "RPN Calculator" do
  before(:each) do
     @calculator = RpnCalculator.new
  end 
 
  def enter_number(number) 
    number.to_s.each_char{ |d| @calculator.digit_pressed d }
    @calculator.execute_function(:enter)
  end
 
  describe "Basic Creation" do
    it "should be non-null after creation" do
      @calculator.should_not be nil
    end
  end
 
  describe "Handling integers" do
    it "should store a series of digits in the x register" do
      enter_number 42
      @calculator.x_register.should == 42
    end
 
    it "should handle a string of digits with an embedded ." do
      enter_number 13.31
      @calculator.x_register.should == 13.31
    end
  end
 
  describe "Handling the <enter> key" do
    before(:each) do
       enter_number 654
    end
 
    it "should copy x_register to top of stack" do
      @calculator.top.should == 654
    end
 
    it "should cause next digit to reset the x_register" do
      @calculator.digit_pressed 1
      @calculator.x_register.should == 1
    end
 
    it "should allow the x_register to be <entered> again" do
      @calculator.execute_function(:enter)
      @calculator.top.should == 654
      @calculator.x_register.should == 654
    end
 
    it "should only reset after the first digit and not subsequent digits" do
      enter_number 27
      @calculator.x_register.should == 27
    end
 
    it "should have two operands available after one <enter>" do
      @calculator.available_operands.should == 2
    end
 
    it "should increase the operand count after each <enter>" do
      enter_number 13
      @calculator.available_operands.should == 3
    end
 
    it "should contain the correct items in the correct order" do
      enter_number 4
      enter_number 19
      enter_number -1
      @calculator.pop!.should == -1
      @calculator.pop!.should == 19
      @calculator.pop!.should == 4
    end
  end
end

require 'operand_stack'
 
class RpnCalculator
  def initialize
    reset_input
    @operand_stack = OperandStack.new
  end
 
  def digit_pressed(digit)
    reset_input if @x_register_should_reset
    @input << digit.to_s
  end
 
  def reset_input
    @input = ''
    @x_register_should_reset = false
  end
 
  def x_register
    @input.to_f
  end
 
  def execute_function(function_symbol)
    @x_register_should_reset = true
    @operand_stack << x_register
  end
 
  def top
    @operand_stack.top
  end
 
  def available_operands
    @operand_stack.length + 1
  end
 
  def pop!
    @operand_stack.pop!
  end
end

require "operand_stack"
 
describe "OperandStack" do
  before (:each) do
    @stack = OperandStack.new
  end 
 
  it "should return 0 when pop!'ing from an empty stack" do
    @stack.pop!.should == 0
  end 
 
  it "should return 0 for top when stack empty" do
    @stack.top.should == 0
  end 
end 

class OperandStack
  def initialize
    @operands = []
  end 
 
  def top
    @operands.length > 0 ? @operands.last : 0
  end
 
  def available_operands
    @operands.length + 1
  end
 
  def pop!
    @operands.length > 0 ? @operands.pop : 0
  end
 
  def <<(value)
    @operands << value
  end
 
  def length
    @operands.length
  end
end 

Example: A Binary Operator

  def execute_function(function_symbol)
    @x_register_should_reset = true
    @operand_stack << x_register
  end

  describe "Basic Math Operators" do
    it "should add the x_regiser and the top of the stack" do
      enter_number 46
      @calculator.execute_function(:+)
      @calculator.x_register.should == 92
    end
  end

• Create this Example and run it. The result is not quite right:
  

  1)
  'RPN Calculator Basic Math Operators should add the x_regiser and the top of the stack' FAILED
  expected: 700,
       got: 46.0 (using ==)
  ./rpn_calculator_spec.rb:79:
   
  Finished in 0.03118 seconds
   
  13 examples, 1 failure

• Getting this to pass is a "snap":
  

    def execute_function(function_symbol)
      if function_symbol == :enter
        @x_register_should_reset = true
        @operand_stack << x_register
      elsif
        @input = 92.to_s
      end
    end

• Get your Examples passing.

• Determine which function to perform
• Actually perform the work.

• Extract two methods, enter, +:
  

    def enter
      @x_register_should_reset = true
      @operand_stack << x_register
    end 
   
    def +
      @input = 92.to_s
    end

• Make sure your Examples still pass.

• Update the execute_function to use those two methods:
  

    def execute_function(function_symbol)
      if function_symbol == :enter
        enter
      else
        self.+
      end
    end

• Update your RpnCalculator, verify that your Examples are all passing.

Example: Work on +

    it "should result in 0 when the calculator is empty" do
      @calculator.execute_function(:+)
      @calculator.x_register.should == 0
    end

• Create this Example. Verify that it fails.

• Update the + method to actually do some work.
  

    def enter
      @x_register_should_reset = true
      @operand_stack << x_register
    end

• Run your Example, make sure it works.

    @input = result.to_s

Example: x_register in reset mode after +

    it "should reset the x_register after +" do
      enter_number 99
      @calculator.execute_function(:+)
      @calculator.digit_pressed 8
      @calculator.x_register.should == 8
    end

• Create this Example. Run it and you'll notice that it fails:
  

  1)
  'RPN Calculator Basic Math Operators should reset the x_register after +' FAILED
  expected: 8,
       got: 9.08 (using ==)
  ./rpn_calculator_spec.rb:91:
   
  Finished in 0.032479 seconds
   
  16 examples, 1 failure

• Make a quick change to the + method to fix this:
  

    def +
      lhs = @operand_stack.pop!
      rhs = x_register
      result = lhs + rhs
      @input = result.to_s
      @x_register_should_reset = true
    end

• Run your Examples, they should all pass.

    @x_register_should_reset = true

• Create a new method (if your IDE supports Extract method, use it):
  

    def set_override_mode
      @x_register_should_reset = true
    end

• Make sure your Examples still pass.

• Update the enter and + methods to call this new method.

• Make sure your Examples still pass.

Example: What about the stack?

    it "should should reduce the stack by one" do
      enter_number 9
      enter_number 8
      @calculator.execute_function :+
      @calculator.available_operands.should == 2
    end

• Create this example.

• Run your Examples. Notice it passes.

    @input = result.to_s
    set_override_mode

    lhs = @operand_stack.pop!
    rhs = x_register

• Add a new method that is private (since private sets subsequent methods, make this the last method in your RpnCalculatorClass):
  

    private
    def reset_x_register(value)
      @input = value.to_s
      set_override_mode
    end

• Verify your Examples still pass.

• Update +:
  

    def +
      lhs = @operand_stack.pop!
      rhs = x_register
      result = lhs + rhs
      reset_x_register result
    end

• Verify your Examples still pass.

• Check in this refactoring.

• Check in your refactoring.

Example: Support for a new binary operator, -

    it "should subtract the first number entered from the second" do
      enter_number 4
      @calculator.digit_pressed 9
      @calculator.execute_function :-
      @calculator.x_register.should == -5
    end

• Create this example. Run your examples and verify that they do not pass.

  def execute_function(function_symbol)
    if function_symbol == :enter
      enter
    else
      self.+
    end
  end

• Your execute_function should fail if the operator is not found.

• However, you are not working on that Example. So update this method to call -:
  

    def execute_function(function_symbol)
      if function_symbol == :enter
        enter
      elsif function_symbol == :+
        self.+
      elsif function_symbol == :-
        self.-
      end
    end

• Now your code is missing the function - (which you discovered by running your Examples, right?), so add it:
  

    def -
    end

• Run your Example, now it should be failing for the right reason (value did not match).

• Create a method that is hard-coded to return the correct value.
• Create a duplicate of the + method and change it to be -

• Rather than following the third rule, you can safely duplicate the + method and update it (you'll be refactoring this soon anyway):
  

    def -
      lhs = @operand_stack.pop!
      rhs = x_register
      result = lhs - rhs
      reset_x_register result
    end

• Verify that all of your Examples are passing.

1. Adding a new operator requires too much work: update a method, add a new method, and write that method. More importantly, it requires changing an existing method which is in direct violation of the open/close principle.
2. The execute_function does not indicate if the function does not exist.
3. There is duplicated code between the + and - methods. (This was on your list, wasn't it?)
4. The difference between enter_number and digit_pressed seems isn't obvious.
5. The Examples should not have such a mix of lines that use fields and support methods.

• Update execute_function:
  

    def execute_function(function_symbol)
      self.send(function_symbol)
    end

• Run your Examples to verify that they all pass.

• Removes the need to update this method ever again
• Requires, however, that the functions of the calculator are actually methods on the class.
• Your code now will fail if you attempt to send a method that is unknown
• Allows invocation of (0 argument) private methods

• Check in your change.

• Add a new private method to your RpnCalculator method:
  

    def execute_binary_operator
      lhs = @operand_stack.pop!
      rhs = x_register
      result = yield lhs, rhs
      reset_x_register result
    end

• Make sure your Examples still pass.

• Update the + method:
  

    def +
      execute_binary_operator { |lhs, rhs| lhs + rhs }
    end

• Run your Examples, make sure they still pass.

• Update the - method:
  

    def +
      execute_binary_operator { |lhs, rhs| lhs + rhs }
    end

• Run your Examples, make sure they still pass.

• Add some new support methods (put these at the same place as enter_number):
  

    def type(number)
      number.to_s.each_char{ |d| @calculator.digit_pressed d }
    end
   
    def press(a_symbol)
      @calculator.send(a_symbol)
    end
   
    def validate_x_register(expected)
      @calculator.x_register.should == expected
    end

• Make sure your examples still pass.

• Update "should subtract the first ...":
  

      it "should subtract the first number entered from the second" do
        type 4
        press :enter
        type 9
        press :-
        validate_x_register -5
      end 

• Run your Examples, they should all pass.

  describe "Basic Math Operators" do
    it "should add the x_regiser and the top of the stack" do
      type 46
      press :enter
      press :+
      validate_x_register 92
    end
 
    it "should result in 0 when the calculator is empty" do
      press :+
      validate_x_register 0
    end
 
    it "should reset the x_register after +" do
      type 9
      press :+
      type 8
      validate_x_register 8
    end
 
    it "should should reduce the stack by one" do
      type 9
      press :enter
      type 8
      press :enter
      press :+
      @calculator.available_operands.should == 2
    end
 
    it "should subtract the first number entered from the second" do
      type 4
      press :enter
      type 9
      press :-
      validate_x_register -5
    end
  end

  @calculator.type 4
  @calculator.press :enter
  @calculator.type 52
  @calculator.press :+
  @calculator.x_register.should == 56

require 'rpn_calculator'
 
describe "RPN Calculator" do
  before(:each) do
     @calculator = RpnCalculator.new
  end
 
  def type(number)
    number.to_s.each_char{ |d| @calculator.digit_pressed d }
  end
 
  def press(a_symbol)
    @calculator.execute_function a_symbol
  end
 
  def validate_x_register(expected)
    @calculator.x_register.should == expected
  end
 
  def validate_top(expected)
    @calculator.top.should == expected
  end
 
  def validate_operands(expected)
    @calculator.available_operands.should == expected
  end
 
  def validate_pop!(expected)
    @calculator.pop!.should == expected
  end
 
  describe "Basic Creation" do
    it "should be non-null after creation" do
      @calculator.should_not be nil
    end
  end
 
  describe "Handling integers" do
    it "should store a series of digits in the x register" do
      type 42
      press :enter
      validate_x_register 42
    end
 
    it "should handle a string of digits with an embedded ." do
      type 13.31
      validate_x_register 13.31
    end
  end
 
  describe "Handling the <enter> key" do
    before(:each) do
      type 654
      press :enter
    end
 
    it "should copy x_register to top of stack" do
      validate_top 654
    end
 
    it "should cause next digit to reset the x_register" do
      @calculator.digit_pressed 1
      @calculator.x_register.should == 1
    end
 
    it "should allow the x_register to be <entered> again" do
      press :enter
      validate_top 654  
      validate_x_register 654
    end
 
    it "should only reset after the first digit and not subsequent digits" do
      type 27
      validate_x_register 27
    end
 
    it "should have two operands available after one <enter>" do
      validate_operands 2
    end
 
    it "should increase the operand count after each <enter>" do
      type 13
      press :enter
      validate_operands 3
    end
 
    it "should contain the correct items in the correct order" do
      type 4
      press :enter
      type 19
      press :enter
      type -1
      press :enter
      validate_pop! -1
      validate_pop! 19
      validate_pop! 4
    end
  end
 
  describe "Basic Math Operators" do
    it "should add the x_regiser and the top of the stack" do
      type 46
      press :enter
      press :+
      validate_x_register 92
    end
 
    it "should result in 0 when the calculator is empty" do
      press :+
      validate_x_register 0
    end
 
    it "should reset the x_register after +" do
      type 9
      press :+
      type 8
      validate_x_register 8
    end
 
    it "should should reduce the stack by one" do
      type 9
      press :enter
      type 8
      press :enter
      press :+
      @calculator.available_operands.should == 2
    end
 
    it "should subtract the first number entered from the second" do
      type 4
      press :enter  
      type 9
      press :-
      validate_x_register -5
    end
  end
end

• Get to where all of your Examples are passing.

• Check in your work.

• The execute_function method now uses the send method to execute a symbol, so you will not have to update it so long as new functions are added to the RpnCalculator clss.
  As a result of this change, your execute_function will indicate errors better than when you added an Example for - (which caused + to get called)
• You created an execute_binary_operator method that makes adding binary operators a one-line lambda expression.
  As a result, you removed some DRY violations.
• You made a significant change to how you write your examples.

Example: Handling missing functions

  describe "Handling Functions" do
    it "should raise an exception if attempting to run missing function" do
      lambda { press :bogus_function_name }.should raise_error NoMethodError
    end
  end

• Create this new Context and verify that it passes.

• Check in your code.

Example: Add support for * and /

    it "should multiply the first number entered by the second" do
      type 3
      press :enter 
      type 9
      press :*
      validate_x_register 27
    end

• Create this example. Run it and verify that your test fails with a missing method.

• Create the method:
  

    def *
      execute_binary_operator { |lhs, rhs| lhs * rhs }
    end 

• Verify that your Examples pass.

    it "should divide the first number entered by the second" do
      type 9
      press :enter
      type 3
      press :/
      validate_x_register 3
    end

• Add the missing method:
  

    def /
      execute_binary_operator { |lhs, rhs| lhs / rhs }
    end

• Verify that your Examples pass.

Example x

Example x